package com.gxc.recursion;

import java.nio.CharBuffer;
import java.util.*;

/**
 * 题目描述
 * 有N（3 ≤ N < 10000）个运动员，他们的id为0到N-1,他们的实力由一组整数表示。他们之间进行比赛，需要决出冠亚军。比赛的规则是0号和1号比赛，2号和3号比赛，以此类推，每一轮，相邻的运动员进行比赛，获胜的进入下一轮；实力值大的获胜，实力值相等的情况，id小的情况下获胜；轮空的直接进入下一轮。
 *
 * 输入描述
 * 输入一行N个数字代表N的运动员的实力值(0<=实力值<=10000000000)。
 *
 * 输出描述
 * 输出冠亚季军的id，用空格隔开。
 */
public class Champion {

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        String numStr = scanner.nextLine();
        String[] strengthArr = numStr.split(" ");

        int[] strength = new int[strengthArr.length];
        Queue<Integer> firstQueue = new LinkedList<>();
        Queue<Integer> secondQueue = new LinkedList<>();
        for (int i = 0; i < strengthArr.length; i++) {
            firstQueue.add(i);
            strength[i] = Integer.parseInt(strengthArr[i]);
        }
        while (firstQueue.size()>4) {
            while (!firstQueue.isEmpty()) {
                Integer first = firstQueue.poll();
                Integer second = null;
                if (!firstQueue.isEmpty()) second = firstQueue.poll();
                if (second == null) {
                    secondQueue.add(first);
                } else {
                    if (strength[first] == strength[second]) {
                        secondQueue.add(first);
                    } else if (strength[first] > strength[second]){
                        secondQueue.add(first);
                    } else {
                        secondQueue.add(second);
                    }
                }
            }
            while (!secondQueue.isEmpty()) {
                firstQueue.add(secondQueue.poll());
            }
        }

        Integer one = firstQueue.poll();
        Integer two = firstQueue.poll();
        Queue<Integer> finalQueue = new LinkedList<>();
        Queue<Integer> semiFinalQueue = new LinkedList<>();
        if (strength[one] == strength[two]) {
            finalQueue.add(one);
            semiFinalQueue.add(two);
        } else if (strength[one] > strength[two]){
            finalQueue.add(one);
            semiFinalQueue.add(two);
        } else {
            finalQueue.add(two);
            semiFinalQueue.add(one);
        }
        Integer three = firstQueue.poll();
        if (firstQueue.isEmpty()) {
            finalQueue.add(three);
        } else {
            Integer four = firstQueue.poll();
            if (strength[three] == strength[four]) {
                finalQueue.add(three);
                semiFinalQueue.add(four);
            } else if (strength[three] > strength[four]){
                finalQueue.add(three);
                semiFinalQueue.add(four);
            } else {
                finalQueue.add(four);
                semiFinalQueue.add(three);
            }
        }
        int x = finalQueue.poll();
        int y = finalQueue.poll();
        if (strength[x] < strength[y]){
            one = y;
            two = x;
        } else {
            one = x;
            two = y;
        }
        x = semiFinalQueue.poll();
        if (semiFinalQueue.isEmpty()) {
            three = x;
        } else {
            y = semiFinalQueue.poll();
            if (strength[x] < strength[y]){
                three = y;
            } else {
                three = x;
            }
        }

        System.out.print(one + " " + two + " " + three);
    }

    // 运动员类
    static class Sport {
        int id; // 运动员的id
        long strength; // 运动员的实力

        public Sport(int id, long strength) {
            this.id = id;
            this.strength = strength;
        }
    }

    public static void main2(String[] args) {
        Scanner sc = new Scanner(System.in);

        long[] strengths = Arrays.stream(sc.nextLine().split(" ")).mapToLong(Long::parseLong).toArray();

        System.out.println(getResult(strengths));
    }

    public static String getResult(long[] strength) {
        // ans只记录三个组，冠军组，亚军组，季军组
        LinkedList<ArrayList<Sport>> ans = new LinkedList<>();

        // 将输入的实力值，转化为运动员集合
        ArrayList<Sport> sports = new ArrayList<>();
        for (int i = 0; i < strength.length; i++) sports.add(new Sport(i, strength[i]));

        // 晋级赛
        promote(sports, ans);

        // 冠军组如果不是一个人，那么还需要取出冠军组继续进行晋级赛
        while (ans.getFirst().size() > 1) {
            promote(ans.removeFirst(), ans);
        }

        // 冠军
        int first = ans.get(0).get(0).id;

        // 亚军
        int second = ans.get(1).get(0).id;

        // 季军
        ans.get(2)
                .sort(
                        (a, b) ->
                                a.strength != b.strength ? b.strength - a.strength > 0 ? 1 : -1 : a.id - b.id);

        int third = ans.get(2).get(0).id;
        return first + " " + second + " " + third;
    }

    public static void promote(ArrayList<Sport> sports, LinkedList<ArrayList<Sport>> ans) {
        // 记录获胜组
        ArrayList<Sport> win = new ArrayList<>();
        // 记录失败组
        ArrayList<Sport> fail = new ArrayList<>();

        for (int i = 1; i < sports.size(); i += 2) {
            // 序号大的运动员
            Sport major = sports.get(i);
            // 序号小的运动员
            Sport minor = sports.get(i - 1);

            if (major.strength > minor.strength) {
                win.add(major);
                fail.add(minor);
            } else {
                // 如果序号大的运动员的实力 <= 序号小的运动员，则序号小的运动员获胜
                win.add(minor);
                fail.add(major);
            }
        }

        // 如果晋级赛中运动员个数是奇数个，那么最后一个运动员直接晋级
        if (sports.size() % 2 != 0) {
            win.add(sports.get(sports.size() - 1));
        }

        // 依次头部压入失败组，获胜组，保证头部是获胜组
        ans.addFirst(fail);
        ans.addFirst(win);

        // 如果保留组个数超过3个，那么需要将超过部分的组去掉，因为这部分人已经无缘季军
        while (ans.size() > 3) ans.removeLast();
    }
}

